﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using DynamicAuditor.DTOs;
using DynamicAuditor.DALAuditor;

namespace Negocio
{
    /// <summary>
    /// Summary description for WsNegocio
    /// </summary>
    [WebService(Namespace = "DynamicAuditor")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line. 
    // [System.Web.Script.Services.ScriptService]
    public class WsCobit : System.Web.Services.WebService
    {

        #region MANTENIMIENTOS DE VERSIONES COBIT

        /// <summary>
        /// METODO QUE PERMITE CREAR UNA NUEVA VERSION COBIT
        /// </summary>
        [WebMethod]
        public int CrearVersionCobit(dtoVersionCobit version)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsVersionCobitMg nuevo = new clsVersionCobitMg();

            try
            {
                resp = nuevo.InsertVersionCobit(version);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear la version COBIT." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR LA VERSION COBIT 
        /// </summary>
        [WebMethod]
        public int ActualizarVersionCobit(dtoVersionCobit version)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsVersionCobitMg nuevo = new clsVersionCobitMg();

            try
            {
                resp = nuevo.UpdateVersionCobit(version);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar la version cobit" + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR LA VERSION COBIT
        /// </summary>
        [WebMethod]
        public int EliminarVersionCobit(dtoVersionCobit version)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsVersionCobitMg nuevo = new  clsVersionCobitMg();

            try
            {
                resp = nuevo.DeleteVersionCobit(version );
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar la versión cobit." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS VERSIONES COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoVersionCobit> getTodosVersionCobit()
        {

            List<dtoVersionCobit> listaVersiones = new List<dtoVersionCobit>();

            try
            {
                DynamicAuditor.DALAuditor.clsVersionCobitMg dalListaVersiones = new clsVersionCobitMg();
                listaVersiones = dalListaVersiones.ObtenerListaVersionCobit();



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de versiones Cobit");

            }



            return listaVersiones;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS VERSIONES COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoVersionCobit> getVersionCobitActivas()
        {

            List<dtoVersionCobit> listaVersiones = new List<dtoVersionCobit>();

            try
            {
                DynamicAuditor.DALAuditor.clsVersionCobitMg dalListaVersiones = new clsVersionCobitMg();
                listaVersiones = dalListaVersiones.ObtenerListaVersionCobitActivas();



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de versiones Cobit");

            }



            return listaVersiones;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA VERSION COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public dtoVersionCobit getInfoVersionCobit(int idVersionCobit)
        {
            dtoVersionCobit dato = new dtoVersionCobit();

            try
            {

                dato = new clsVersionCobitMg().ObtenerVersionPorId(idVersionCobit);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos de la version cobit" + ex.ToString());

            }
            return dato;



        }



        #endregion

        
        #region MANTENIMIENTO DE DOMINIOS


        /// <summary>
        /// METODO QUE PERMITE CREAR UN NUEVO DOMINIO COBIT
        /// </summary>
        [WebMethod]
        public int CrearDominioCobit(dtoDominios dominio)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsDominioMg nuevo = new clsDominioMg();

            try
            {
                resp = nuevo.InsertDominioCobit(dominio);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el dominio." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UN  DOMINIO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarDominioCobit(dtoDominios dominio)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsDominioMg nuevo = new clsDominioMg();

            try
            {
                resp = nuevo.UpdateDominioCobit(dominio);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el dominio." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UN  DOMINIO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarDominioCobit(dtoDominios dominio)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsDominioMg nuevo = new clsDominioMg();

            try
            {
                resp = nuevo.DeleteDominioCobit(dominio);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el dominio." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS DOMINIO COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoDominios> getTodosDominiosCobit(int idversion)
        {

            List<dtoDominios> listaDominios = new List<dtoDominios>();

            try
            {
                DynamicAuditor.DALAuditor.clsDominioMg dalListaDominios = new clsDominioMg();
                listaDominios = dalListaDominios.ObtenerDominiosCobit(idversion );



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de dominios Cobit");

            }



            return listaDominios;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS DOMINIO COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoDominios> getDominiosCobitActivos(int idversion)
        {

            List<dtoDominios> listaDominios = new List<dtoDominios>();

            try
            {
                DynamicAuditor.DALAuditor.clsDominioMg dalListaDominios = new clsDominioMg();
                listaDominios = dalListaDominios.ObtenerDominiosCobitActivos(idversion);



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de dominios Cobit");

            }



            return listaDominios;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER DE UN DOMINIO COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public dtoDominios getInfoDominioCobit(int idDominioCobit) {
            dtoDominios dato = new dtoDominios();

            try {

                dato = new clsDominioMg().ObtenerDominioCobitporId(idDominioCobit);           
            
            }catch ( Exception ex){
                dato = null;
                throw new Exception("Error al obtener los datos del dominio cobit" + ex.ToString());
            
            }
            return dato;
        
        
        
        }











        #endregion


        #region PROCESOSCOBIT

        #region MANTENIMIENTOS DE PROCESOS COBIT
        /// <summary>
        /// METODO QUE PERMITE CREAR UN NUEVO PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearProcesoCobit(dtoProcesoCobit proceso)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoCobitMg nuevo = new clsProcesoCobitMg();

            try
            {
                resp = nuevo.InsertProcesoCobit(proceso);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el proceso." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UN  PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarProcesoCobit(dtoProcesoCobit proceso)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoCobitMg nuevo = new clsProcesoCobitMg();

            try
            {
                resp = nuevo.UpdateProcesoCobit(proceso);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el proceso." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UN  PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarProcesoCobit(dtoProcesoCobit proceso)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoCobitMg nuevo = new clsProcesoCobitMg();

            try
            {
                resp = nuevo.DeleteProcesoCobit(proceso);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el proceso." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS PROCESOS COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoCobit> getTodosProcesosCobit(int idDominio)
        {

            List<dtoProcesoCobit> listaProcesos = new List<dtoProcesoCobit>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoCobitMg dalListaProcesos = new clsProcesoCobitMg();
                listaProcesos = dalListaProcesos.ObtenerProcesosCobit(idDominio);



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaProcesos;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS PROCESOS COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoCobit> getProcesosCobitActivos(int idDominio)
        {

            List<dtoProcesoCobit> listaProcesos = new List<dtoProcesoCobit>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoCobitMg dalListaProcesos = new clsProcesoCobitMg();
                listaProcesos = dalListaProcesos.ObtenerProcesosCobitActivos(idDominio);



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de dominios Cobit");

            }



            return listaProcesos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS PROCESOS COBIT RELACIONADOS A LA ULTIMA VERSION COBIT REGISTRADA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoCobit> getProcesosCobitActivosByLastVersionCobit()
        {

            List<dtoProcesoCobit> listaProcesos = new List<dtoProcesoCobit>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoCobitMg dalListaProcesos = new clsProcesoCobitMg();
                listaProcesos = dalListaProcesos.ObtenerProcesosUltimaVersionCobit();
               

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de dominios Cobit");

            }



            return listaProcesos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER PROCESO COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoCobit getInfoProcesoCobit(int idProcesoCobit)
        {
            dtoProcesoCobit dato = new dtoProcesoCobit();

            try
            {

                dato = new clsProcesoCobitMg().ObtenerProcesoCobitporId(idProcesoCobit);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos del proceso cobit" + ex.ToString());

            }
            return dato;



        }





        /// <summary>
        /// METODO QUE PERMITE OBTENER PROCESO COBIT REGISTRADOS EN EL SISTEMA POR SIGLAS
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoCobit getInfoProcesoCobitBySiglas(string siglas)
        {
            dtoProcesoCobit dato = new dtoProcesoCobit();

            try
            {

                dato = new clsProcesoCobitMg().ObtenerProcesoCobitporSiglas(siglas);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos del proceso cobit" + ex.ToString());

            }
            return dato;



        }



        #endregion

        
        #region MANTENIMIENTO DE PROCESOS_ACTIVIDADES
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA ACTIVIDAD PARA UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearProcesoActividad(dtoProcesoActividad nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoActividadMg registro = new clsProcesoActividadMg();

            try
            {
                resp = registro.InsertProcesoActividad(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA ACTIVIDAD RELACIONADA A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarProcesoActividad(dtoProcesoActividad nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoActividadMg registro = new clsProcesoActividadMg();

            try
            {
                resp = registro.UpdateProcesoActividad(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA ACTIVIDAD RELACIONADA A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarProcesoActividad(dtoProcesoActividad nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoActividadMg registro = new clsProcesoActividadMg();

            try
            {
                resp = registro.DeleteProcesoActividad(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA ACTIVIDAD RELACIONADA A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoActividad getInfoProcesoActividad(int idactividad)
        {
            dtoProcesoActividad dato = new dtoProcesoActividad();

            try
            {

                dato = new clsProcesoActividadMg().ObtenerProcesoActividadporId(idactividad);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ACTIVIDADES RELACIONADAS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoActividad> getTodosProcesosActividades(int idproceso)
        {

            List<dtoProcesoActividad> listaDatos = new List<dtoProcesoActividad>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoActividadMg dalListaDatos = new clsProcesoActividadMg();
                listaDatos = dalListaDatos.ObtenerProcesosActividadesLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ACTIVIDADES ACTIVAS RELACIONADAS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoActividad> getTodosProcesosActividadesActivos(int idproceso)
        {

            List<dtoProcesoActividad> listaDatos = new List<dtoProcesoActividad>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoActividadMg dalListaDatos = new clsProcesoActividadMg();
                listaDatos = dalListaDatos.ObtenerProcesosActividadesActivosLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ACTIVIDADES COBIT RELACIONADAS A UN CLIENTE
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoActividad> getTodosProcesosActividadesByCliente(int idcliente)
        {

            List<dtoProcesoActividad> listaDatos = new List<dtoProcesoActividad>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoActividadMg dalListaDatos = new clsProcesoActividadMg();
                listaDatos = dalListaDatos.ObtenerProcesosActividadesByCliente(idcliente);
                
            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }



       





        #endregion 


        #region MANTENIMIENTO DE PROCESOS_RIESGOS
        /// <summary>
        /// METODO QUE PERMITE CREAR UN RIESGO PARA UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearProcesoRiesgo(dtoProcesoRiesgo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoRiesgoMg registro = new clsProcesoRiesgoMg();

            try
            {
                resp = registro.InsertProcesoRiesgo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UN RIESGO RELACIONADO A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarProcesoRiesgo(dtoProcesoRiesgo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoRiesgoMg registro = new clsProcesoRiesgoMg();

            try
            {
                resp = registro.UpdateProcesoRiesgo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UN RIESGO RELACIONADO A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarProcesoRiesgo(dtoProcesoRiesgo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoRiesgoMg registro = new clsProcesoRiesgoMg();

            try
            {
                resp = registro.DeleteProcesoRiesgo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UN RIESGO RELACIONADO A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoRiesgo getInfoProcesoRiesgo(int idriesgo)
        {
            dtoProcesoRiesgo dato = new dtoProcesoRiesgo();

            try
            {

                dato = new clsProcesoRiesgoMg().ObtenerProcesoRiesgoporId(idriesgo);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LOS RIESGOS RELACIONADOS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoRiesgo> getTodosProcesosRiesgos(int idproceso)
        {

            List<dtoProcesoRiesgo> listaDatos = new List<dtoProcesoRiesgo>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoRiesgoMg dalListaDatos = new clsProcesoRiesgoMg();
                listaDatos = dalListaDatos.ObtenerProcesosRiesgosLista(idproceso );

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS RIESGOS ACTIVOS RELACIONADAS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoRiesgo> getTodosProcesosRiesgosActivos(int idproceso)
        {

            List<dtoProcesoRiesgo> listaDatos = new List<dtoProcesoRiesgo>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoRiesgoMg dalListaDatos = new clsProcesoRiesgoMg();
                listaDatos = dalListaDatos.ObtenerProcesosRiesgosActivosLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LOS RIESGOS COBIT RELACIONADAS A UN CLIENTE
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoRiesgo> getTodosProcesosRiesgosByCliente(int idcliente)
        {

            List<dtoProcesoRiesgo> listaDatos = new List<dtoProcesoRiesgo>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoRiesgoMg dalListaDatos = new clsProcesoRiesgoMg();
                listaDatos = dalListaDatos.ObtenerProcesosRiesgosByCliente(idcliente);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }









        #endregion 
        
      
        #region MANTENIMIENTO DE PROCESOS_OBJETIVOS
        /// <summary>
        /// METODO QUE PERMITE CREAR UN OBJETIVO PARA UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearProcesoObjetivo(dtoProcesoObjetivo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoObjetivoMg registro = new clsProcesoObjetivoMg();

            try
            {
                resp = registro.InsertProcesoObjetivo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UN OBJETIVO RELACIONADO A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarProcesoObjetivo(dtoProcesoObjetivo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoObjetivoMg registro = new clsProcesoObjetivoMg();

            try
            {
                resp = registro.UpdateProcesoObjetivo(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UN OBJETIVO RELACIONADO A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarProcesoObjetivo(dtoProcesoObjetivo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoObjetivoMg registro = new clsProcesoObjetivoMg();

            try
            {
                resp = registro.DeleteProcesoObjetivo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UN OBJETIVO RELACIONADO A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoObjetivo getInfoProcesoObjetivo(int idobjetivo)
        {
            dtoProcesoObjetivo dato = new dtoProcesoObjetivo();

            try
            {

                dato = new clsProcesoObjetivoMg().ObtenerProcesoObjetivoporId(idobjetivo);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS OBJETIVOS RELACIONADOS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoObjetivo> getTodosProcesosObjetivos(int idproceso)
        {

            List<dtoProcesoObjetivo> listaDatos = new List<dtoProcesoObjetivo>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoObjetivoMg dalListaDatos = new clsProcesoObjetivoMg();
                listaDatos = dalListaDatos.ObtenerProcesosObjetivosLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS ENTRADAS ACTIVOS RELACIONADAS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoObjetivo> getTodosProcesosObjetivosActivos(int idproceso)
        {

            List<dtoProcesoObjetivo> listaDatos = new List<dtoProcesoObjetivo>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoObjetivoMg dalListaDatos = new clsProcesoObjetivoMg();
                listaDatos = dalListaDatos.ObtenerProcesosObjetivosActivosLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }

        #endregion 


        #region MANTENIMIENTO DE PROCESOS_ENTRADAS
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA ENTRADA PARA UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearProcesoEntrada(dtoProcesoEntrada nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoEntradaMg registro = new clsProcesoEntradaMg();

            try
            {
                resp = registro.InsertProcesoEntrada(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA ENTRADA RELACIONADA A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarProcesoEntrada(dtoProcesoEntrada nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoEntradaMg registro = new clsProcesoEntradaMg();

            try
            {
                resp = registro.UpdateProcesoEntrada(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA ENTRADA RELACIONADO A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarProcesoEntrada(dtoProcesoEntrada nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoEntradaMg registro = new clsProcesoEntradaMg();

            try
            {
                resp = registro.DeleteProcesoEntrada(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA ENTRADA RELACIONADA A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoEntrada getInfoProcesoEntrada(int identrada)
        {
            dtoProcesoEntrada dato = new dtoProcesoEntrada();

            try
            {

                dato = new clsProcesoEntradaMg().ObtenerProcesoEntradaporId(identrada);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ENTRADAS RELACIONADOS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoEntrada> getTodosProcesosEntradas(int idproceso)
        {

            List<dtoProcesoEntrada> listaDatos = new List<dtoProcesoEntrada>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoEntradaMg dalListaDatos = new clsProcesoEntradaMg();
                listaDatos = dalListaDatos.ObtenerProcesosEntradaLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS ENTRADAS ACTIVOS RELACIONADAS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoEntrada> getTodosProcesosEntradasActivos(int idproceso)
        {

            List<dtoProcesoEntrada> listaDatos = new List<dtoProcesoEntrada>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoEntradaMg dalListaDatos = new clsProcesoEntradaMg();
                listaDatos = dalListaDatos.ObtenerProcesosEntradaLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }

        #endregion 

        #region MANTENIMIENTO DE PROCESOS_SALIDAS
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA SALIDA PARA UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearProcesoSalida(dtoProcesoSalida nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoSalidaMg registro = new clsProcesoSalidaMg();

            try
            {
                resp = registro.InsertProcesoSalida(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA Salida RELACIONADA A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarProcesoSalida(dtoProcesoSalida nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoSalidaMg registro = new clsProcesoSalidaMg();

            try
            {
                resp = registro.UpdateProcesoSalida(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA Salida RELACIONADO A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarProcesoSalida(dtoProcesoSalida nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoSalidaMg registro = new clsProcesoSalidaMg();

            try
            {
                resp = registro.DeleteProcesoSalida(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA Salida RELACIONADA A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoSalida getInfoProcesoSalida(int idSalida)
        {
            dtoProcesoSalida dato = new dtoProcesoSalida();

            try
            {

                dato = new clsProcesoSalidaMg().ObtenerProcesoSalidaporId(idSalida);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS SalidaS RELACIONADOS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoSalida> getTodosProcesosSalidas(int idproceso)
        {

            List<dtoProcesoSalida> listaDatos = new List<dtoProcesoSalida>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoSalidaMg dalListaDatos = new clsProcesoSalidaMg();
                listaDatos = dalListaDatos.ObtenerProcesosSalidaLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS SalidaS ACTIVOS RELACIONADAS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoSalida> getTodosProcesosSalidasActivos(int idproceso)
        {

            List<dtoProcesoSalida> listaDatos = new List<dtoProcesoSalida>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoSalidaMg dalListaDatos = new clsProcesoSalidaMg();
                listaDatos = dalListaDatos.ObtenerProcesosSalidaLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }

        #endregion 


        #region MANTENIMIENTO DE PROCESOS_POLITICAS
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA POLITICA PARA UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearProcesoPolitica(dtoProcesoPolitica nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoPoliticaMg registro = new clsProcesoPoliticaMg();

            try
            {
                resp = registro.InsertProcesoPolitica(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA Politica RELACIONADA A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarProcesoPolitica(dtoProcesoPolitica nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoPoliticaMg registro = new clsProcesoPoliticaMg();

            try
            {
                resp = registro.UpdateProcesoPolitica(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA Politica RELACIONADO A UN PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarProcesoPolitica(dtoProcesoPolitica nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsProcesoPoliticaMg registro = new clsProcesoPoliticaMg();

            try
            {
                resp = registro.DeleteProcesoPolitica(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA Politica RELACIONADA A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoProcesoPolitica getInfoProcesoPolitica(int idPolitica)
        {
            dtoProcesoPolitica dato = new dtoProcesoPolitica();

            try
            {

                dato = new clsProcesoPoliticaMg().ObtenerProcesoPoliticaporId(idPolitica);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS PoliticaS RELACIONADOS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoPolitica> getTodosProcesosPoliticas(int idproceso)
        {

            List<dtoProcesoPolitica> listaDatos = new List<dtoProcesoPolitica>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoPoliticaMg dalListaDatos = new clsProcesoPoliticaMg();
                listaDatos = dalListaDatos.ObtenerProcesosPoliticaLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS PoliticaS ACTIVOS RELACIONADAS A UN PROCESO COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoProcesoPolitica> getTodosProcesosPoliticasActivos(int idproceso)
        {

            List<dtoProcesoPolitica> listaDatos = new List<dtoProcesoPolitica>();

            try
            {
                DynamicAuditor.DALAuditor.clsProcesoPoliticaMg dalListaDatos = new clsProcesoPoliticaMg();
                listaDatos = dalListaDatos.ObtenerProcesosPoliticaLista(idproceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaDatos;
        }

        #endregion 


       
# endregion


        #region SUBPROCESOSCOBIT

        #region MANTENIMIENTOS DE SUBPROCESOS COBIT
        /// <summary>
        /// METODO QUE PERMITE CREAR UN NUEVO SUB PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int CrearSubProcesoCobit(dtoSubProcesoCobit proceso)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoCobitMg nuevo = new clsSubProcesoCobitMg();

            try
            {
                resp = nuevo.InsertSubProcesoCobit(proceso);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el proceso." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UN  SUB PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarSubProcesoCobit(dtoSubProcesoCobit proceso)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoCobitMg nuevo = new clsSubProcesoCobitMg();

            try
            {
                resp = nuevo.UpdateSubProcesoCobit(proceso);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el proceso." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UN   SUB PROCESO COBIT
        /// </summary>
        [WebMethod]
        public int EliminarSubProcesoCobit(dtoSubProcesoCobit proceso)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoCobitMg nuevo = new clsSubProcesoCobitMg();

            try
            {
                resp = nuevo.DeleteSubProcesoCobit(proceso);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el proceso." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS SUB PROCESOS COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoCobit> getTodosSubProcesosCobit(int idProcesoCobit)
        {

            List<dtoSubProcesoCobit> listaSubProcesos = new List<dtoSubProcesoCobit>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoCobitMg dalListaProcesos = new clsSubProcesoCobitMg();
                listaSubProcesos = dalListaProcesos.ObtenerSubProcesosCobit(idProcesoCobit);



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de procesos Cobit");

            }



            return listaSubProcesos;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS PROCESOS SUB COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoCobit> getSubProcesosCobitActivos(int idProceso)
        {

            List<dtoSubProcesoCobit> listaSubProcesos = new List<dtoSubProcesoCobit>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoCobitMg dalListaProcesos = new clsSubProcesoCobitMg();
                listaSubProcesos = dalListaProcesos.ObtenerSubProcesosCobitActivos(idProceso);



            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de dominios Cobit");

            }



            return listaSubProcesos;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER PROCESO COBIT REGISTRADOS EN EL SISTEMA
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoCobit getInfoSubProcesoCobit(int idSubProcesoCobit)
        {
            dtoSubProcesoCobit dato = new dtoSubProcesoCobit();

            try
            {

                dato = new clsSubProcesoCobitMg().ObtenerSubProcesoCobitporId(idSubProcesoCobit);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos del proceso cobit" + ex.ToString());

            }
            return dato;



        }





        /// <summary>
        /// METODO QUE PERMITE OBTENER PROCESO COBIT REGISTRADOS EN EL SISTEMA POR SIGLAS
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoCobit getInfoSubProcesoCobitBySiglas(string siglas)
        {
            dtoSubProcesoCobit dato = new dtoSubProcesoCobit();

            try
            {

                dato = new clsSubProcesoCobitMg().ObtenerSubProcesoCobitporSiglas(siglas);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos del proceso cobit" + ex.ToString());

            }
            return dato;



        }



        #endregion

        #region MANTENIMIENTO DE SubProcesoS_ACTIVIDADES
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA ACTIVIDAD PARA UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int CrearSubProcesoActividad(dtoSubProcesoActividad nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoActividadMg registro = new clsSubProcesoActividadMg();

            try
            {
                resp = registro.InsertSubProcesoActividad(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA ACTIVIDAD RELACIONADA A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarSubProcesoActividad(dtoSubProcesoActividad nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoActividadMg registro = new clsSubProcesoActividadMg();

            try
            {
                resp = registro.UpdateSubProcesoActividad(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA ACTIVIDAD RELACIONADA A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int EliminarSubProcesoActividad(dtoSubProcesoActividad nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoActividadMg registro = new clsSubProcesoActividadMg();

            try
            {
                resp = registro.DeleteSubProcesoActividad(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA ACTIVIDAD RELACIONADA A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoActividad getInfoSubProcesoActividad(int idactividad)
        {
            dtoSubProcesoActividad dato = new dtoSubProcesoActividad();

            try
            {

                dato = new clsSubProcesoActividadMg().ObtenerSubProcesoActividadporId(idactividad);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ACTIVIDADES RELACIONADAS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoActividad> getTodosSubProcesosActividades(int idSubProceso)
        {

            List<dtoSubProcesoActividad> listaDatos = new List<dtoSubProcesoActividad>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoActividadMg dalListaDatos = new clsSubProcesoActividadMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosActividadesLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ACTIVIDADES ACTIVAS RELACIONADAS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoActividad> getTodosSubProcesosActividadesActivos(int idSubProceso)
        {

            List<dtoSubProcesoActividad> listaDatos = new List<dtoSubProcesoActividad>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoActividadMg dalListaDatos = new clsSubProcesoActividadMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosActividadesActivosLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ACTIVIDADES COBIT RELACIONADAS A UN CLIENTE
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoActividad> getTodosSubProcesosActividadesByCliente(int idcliente)
        {

            List<dtoSubProcesoActividad> listaDatos = new List<dtoSubProcesoActividad>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoActividadMg dalListaDatos = new clsSubProcesoActividadMg();
                listaDatos = dalListaDatos.ObtenerProcesosActividadesByCliente(idcliente);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }









        #endregion


        #region MANTENIMIENTO DE SubProcesoS_RIESGOS
        /// <summary>
        /// METODO QUE PERMITE CREAR UN RIESGO PARA UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int CrearSubProcesoRiesgo(dtoSubProcesoRiesgo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoRiesgoMg registro = new clsSubProcesoRiesgoMg();

            try
            {
                resp = registro.InsertSubProcesoRiesgo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UN RIESGO RELACIONADO A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarSubProcesoRiesgo(dtoSubProcesoRiesgo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoRiesgoMg registro = new clsSubProcesoRiesgoMg();

            try
            {
                resp = registro.UpdateSubProcesoRiesgo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UN RIESGO RELACIONADO A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int EliminarSubProcesoRiesgo(dtoSubProcesoRiesgo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoRiesgoMg registro = new clsSubProcesoRiesgoMg();

            try
            {
                resp = registro.DeleteSubProcesoRiesgo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UN RIESGO RELACIONADO A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoRiesgo getInfoSubProcesoRiesgo(int idriesgo)
        {
            dtoSubProcesoRiesgo dato = new dtoSubProcesoRiesgo();

            try
            {

                dato = new clsSubProcesoRiesgoMg().ObtenerSubProcesoRiesgoporId(idriesgo);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LOS RIESGOS RELACIONADOS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoRiesgo> getTodosSubProcesosRiesgos(int idSubProceso)
        {

            List<dtoSubProcesoRiesgo> listaDatos = new List<dtoSubProcesoRiesgo>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoRiesgoMg dalListaDatos = new clsSubProcesoRiesgoMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosRiesgosLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS RIESGOS ACTIVOS RELACIONADAS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoRiesgo> getTodosSubProcesosRiesgosActivos(int idSubProceso)
        {

            List<dtoSubProcesoRiesgo> listaDatos = new List<dtoSubProcesoRiesgo>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoRiesgoMg dalListaDatos = new clsSubProcesoRiesgoMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosRiesgosActivosLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LOS RIESGOS COBIT RELACIONADAS A UN CLIENTE
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoRiesgo> getTodosSubProcesosRiesgosByCliente(int idcliente)
        {

            List<dtoSubProcesoRiesgo> listaDatos = new List<dtoSubProcesoRiesgo>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoRiesgoMg dalListaDatos = new clsSubProcesoRiesgoMg();
                listaDatos = dalListaDatos.ObtenerProcesosRiesgosByCliente(idcliente);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }









        #endregion


        #region MANTENIMIENTO DE SubProcesoS_OBJETIVOS
        /// <summary>
        /// METODO QUE PERMITE CREAR UN OBJETIVO PARA UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int CrearSubProcesoObjetivo(dtoSubProcesoObjetivo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoObjetivoMg registro = new clsSubProcesoObjetivoMg();

            try
            {
                resp = registro.InsertSubProcesoObjetivo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UN OBJETIVO RELACIONADO A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarSubProcesoObjetivo(dtoSubProcesoObjetivo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoObjetivoMg registro = new clsSubProcesoObjetivoMg();

            try
            {
                resp = registro.UpdateSubProcesoObjetivo(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UN OBJETIVO RELACIONADO A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int EliminarSubProcesoObjetivo(dtoSubProcesoObjetivo nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoObjetivoMg registro = new clsSubProcesoObjetivoMg();

            try
            {
                resp = registro.DeleteSubProcesoObjetivo(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UN OBJETIVO RELACIONADO A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoObjetivo getInfoSubProcesoObjetivo(int idobjetivo)
        {
            dtoSubProcesoObjetivo dato = new dtoSubProcesoObjetivo();

            try
            {

                dato = new clsSubProcesoObjetivoMg().ObtenerSubProcesoObjetivoporId(idobjetivo);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LOS OBJETIVOS RELACIONADOS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoObjetivo> getTodosSubProcesosObjetivos(int idSubProceso)
        {

            List<dtoSubProcesoObjetivo> listaDatos = new List<dtoSubProcesoObjetivo>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoObjetivoMg dalListaDatos = new clsSubProcesoObjetivoMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosObjetivosLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS ENTRADAS ACTIVOS RELACIONADAS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoObjetivo> getTodosSubProcesosObjetivosActivos(int idSubProceso)
        {

            List<dtoSubProcesoObjetivo> listaDatos = new List<dtoSubProcesoObjetivo>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoObjetivoMg dalListaDatos = new clsSubProcesoObjetivoMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosObjetivosActivosLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }

        #endregion


        #region MANTENIMIENTO DE SubProcesoS_ENTRADAS
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA ENTRADA PARA UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int CrearSubProcesoEntrada(dtoSubProcesoEntrada nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoEntradaMg registro = new clsSubProcesoEntradaMg();

            try
            {
                resp = registro.InsertSubProcesoEntrada(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA ENTRADA RELACIONADA A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarSubProcesoEntrada(dtoSubProcesoEntrada nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoEntradaMg registro = new clsSubProcesoEntradaMg();

            try
            {
                resp = registro.UpdateSubProcesoEntrada(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA ENTRADA RELACIONADO A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int EliminarSubProcesoEntrada(dtoSubProcesoEntrada nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoEntradaMg registro = new clsSubProcesoEntradaMg();

            try
            {
                resp = registro.DeleteSubProcesoEntrada(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA ENTRADA RELACIONADA A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoEntrada getInfoSubProcesoEntrada(int identrada)
        {
            dtoSubProcesoEntrada dato = new dtoSubProcesoEntrada();

            try
            {

                dato = new clsSubProcesoEntradaMg().ObtenerSubProcesoEntradaporId(identrada);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS ENTRADAS RELACIONADOS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoEntrada> getTodosSubProcesosEntradas(int idSubProceso)
        {

            List<dtoSubProcesoEntrada> listaDatos = new List<dtoSubProcesoEntrada>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoEntradaMg dalListaDatos = new clsSubProcesoEntradaMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosEntradaLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS ENTRADAS ACTIVOS RELACIONADAS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoEntrada> getTodosSubProcesosEntradasActivos(int idSubProceso)
        {

            List<dtoSubProcesoEntrada> listaDatos = new List<dtoSubProcesoEntrada>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoEntradaMg dalListaDatos = new clsSubProcesoEntradaMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosEntradaLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }

        #endregion

        #region MANTENIMIENTO DE SubProcesoS_SALIDAS
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA SALIDA PARA UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int CrearSubProcesoSalida(dtoSubProcesoSalida nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoSalidaMg registro = new clsSubProcesoSalidaMg();

            try
            {
                resp = registro.InsertSubProcesoSalida(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA Salida RELACIONADA A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarSubProcesoSalida(dtoSubProcesoSalida nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoSalidaMg registro = new clsSubProcesoSalidaMg();

            try
            {
                resp = registro.UpdateSubProcesoSalida(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA Salida RELACIONADO A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int EliminarSubProcesoSalida(dtoSubProcesoSalida nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoSalidaMg registro = new clsSubProcesoSalidaMg();

            try
            {
                resp = registro.DeleteSubProcesoSalida(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA Salida RELACIONADA A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoSalida getInfoSubProcesoSalida(int idSalida)
        {
            dtoSubProcesoSalida dato = new dtoSubProcesoSalida();

            try
            {

                dato = new clsSubProcesoSalidaMg().ObtenerSubProcesoSalidaporId(idSalida);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS SalidaS RELACIONADOS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoSalida> getTodosSubProcesosSalidas(int idSubProceso)
        {

            List<dtoSubProcesoSalida> listaDatos = new List<dtoSubProcesoSalida>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoSalidaMg dalListaDatos = new clsSubProcesoSalidaMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosSalidaLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS SalidaS ACTIVOS RELACIONADAS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoSalida> getTodosSubProcesosSalidasActivos(int idSubProceso)
        {

            List<dtoSubProcesoSalida> listaDatos = new List<dtoSubProcesoSalida>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoSalidaMg dalListaDatos = new clsSubProcesoSalidaMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosSalidaLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }

        #endregion


        #region MANTENIMIENTO DE SubProcesoS_POLITICAS
        /// <summary>
        /// METODO QUE PERMITE CREAR UNA POLITICA PARA UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int CrearSubProcesoPolitica(dtoSubProcesoPolitica nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoPoliticaMg registro = new clsSubProcesoPoliticaMg();

            try
            {
                resp = registro.InsertSubProcesoPolitica(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo crear el registro" + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE MODIFICAR UNA Politica RELACIONADA A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int ActualizarSubProcesoPolitica(dtoSubProcesoPolitica nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoPoliticaMg registro = new clsSubProcesoPoliticaMg();

            try
            {
                resp = registro.UpdateSubProcesoPolitica(nuevo);

            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo modificar el registro." + ex.ToString());
            }

            return resp = 0;
        }


        /// <summary>
        /// METODO QUE PERMITE ELIMINAR UNA Politica RELACIONADO A UN SubProceso COBIT
        /// </summary>
        [WebMethod]
        public int EliminarSubProcesoPolitica(dtoSubProcesoPolitica nuevo)
        {
            int resp = 0;

            DynamicAuditor.DALAuditor.clsSubProcesoPoliticaMg registro = new clsSubProcesoPoliticaMg();

            try
            {
                resp = registro.DeleteSubProcesoPolitica(nuevo);
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo eliminar el registro." + ex.ToString());
            }

            return resp = 0;
        }

        /// <summary>
        /// METODO QUE PERMITE OBTENER UNA Politica RELACIONADA A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public dtoSubProcesoPolitica getInfoSubProcesoPolitica(int idPolitica)
        {
            dtoSubProcesoPolitica dato = new dtoSubProcesoPolitica();

            try
            {

                dato = new clsSubProcesoPoliticaMg().ObtenerSubProcesoPoliticaporId(idPolitica);

            }
            catch (Exception ex)
            {
                dato = null;
                throw new Exception("Error al obtener los datos consultados" + ex.ToString());

            }
            return dato;



        }



        /// <summary>
        /// METODO QUE PERMITE OBTENER TODAS LAS PoliticaS RELACIONADOS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoPolitica> getTodosSubProcesosPoliticas(int idSubProceso)
        {

            List<dtoSubProcesoPolitica> listaDatos = new List<dtoSubProcesoPolitica>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoPoliticaMg dalListaDatos = new clsSubProcesoPoliticaMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosPoliticaLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }


        /// <summary>
        /// METODO QUE PERMITE OBTENER TODOS LAS PoliticaS ACTIVOS RELACIONADAS A UN SubProceso COBIT
        /// </summary>
        /// 
        [WebMethod]
        public List<dtoSubProcesoPolitica> getTodosSubProcesosPoliticasActivos(int idSubProceso)
        {

            List<dtoSubProcesoPolitica> listaDatos = new List<dtoSubProcesoPolitica>();

            try
            {
                DynamicAuditor.DALAuditor.clsSubProcesoPoliticaMg dalListaDatos = new clsSubProcesoPoliticaMg();
                listaDatos = dalListaDatos.ObtenerSubProcesosPoliticaLista(idSubProceso);

            }
            catch (Exception ex)
            {
                throw new Exception("Error al obtener la lista de SubProcesos Cobit");

            }



            return listaDatos;
        }

        #endregion


     
        #endregion


    }
}
